High Performance Software Vulnerabilities Detection System and Methods

ABSTRACT

This invention teaches a system and methods of detecting software vulnerabilities in a computer program by analyzing the compiled code and optionally the source code of the computer program. The invention models compiled software to examine both control flow and data flow properties of the target program. A comprehensive instruction model is used for each instruction of the compiled code, and is complemented by a control flow graph that includes all potential control flow paths of the instruction. A data flow model is used to record the flow of unsafe data during the execution of the program. The system analyzes the data flow model and creates a security finding corresponding to each instruction that calls an unsafe function on unsafe data. The security findings are aggregated in a security report. The system further uses precomputation to improve performance by caching 1-to-many data flow mapping for each basic block in the code.

RELATED APPLICATIONS

This invention is a Continuation-in-part of U.S. patent application Ser. No. 14/460,636 filed on 15 Aug., 2014. The above numbered application is incorporated herein in its entirety.

GOVERNMENT LICENSE RIGHTS

This invention was made with government support under the CyberFastTrack program documented in DARPA PA-11-53 dated Jan. 31, 2013, awarded by Defense Advanced Research Projects Agency (DARPA).

FIELD OF THE INVENTION

This invention relates generally to ensuring software security and in particular to exposing software vulnerabilities by performing static and dynamic analysis of compiled software.

BACKGROUND ART

Software security and vulnerability checking is an active field of academic and industrial pursuit. With the news of exploitation of software vulnerabilities by hackers a commonplace occurrence, it is unsurprising to see many academic and professional institutions focusing their efforts to develop tools and practices that aim to make software more secure against exploitative attacks from global hackers and adversaries.

There are many ways of detecting and addressing vulnerabilities in software in the prior art. U.S. Pat. No. 8,499,353 discloses security assessment and vulnerability testing of software applications based in part on application metadata in order to determine an appropriate assurance level and associated test plan that includes multiple types of analysis. Steps from each test are combined into a “custom” or “application-specific” workflow, and the results of each test then correlated with other results to identify potential vulnerabilities.

U.S. Pat. No. 8,365,155 describes a software analysis framework utilizing a decompilation method and system for parsing executable code, identifying and recursively modeling data flows, identifying and recursively modeling control flow and iteratively refining these models to provide a complete model at the nanocode level. The nanocode decompiler may be used to determine flaws, security vulnerabilities, or general quality issues that may exist in the code.

U.S. Pat. No. 8,739,280 describes a context-sensitive taint analysis system. Taint processing applied to a tainted value of an application is identified and an output context of the application associated with output of the tainted value is determined. It is determined whether the taint processing is effective in mitigating a security vulnerability caused by the tainted value for the output context.

U.S. Pat. No. 8,347,392 describes an apparatus and method for analyzing and supplementing a program to provide security. A computer readable storage medium has executable instructions to perform an automated analysis of program instructions. The automated analysis includes at least two analyses selected from an automated analysis of injection vulnerabilities, an automated analysis of potential repetitive attacks, an automated analysis of sensitive information, and automated analysis of specific HTTP attributes. Protective instructions are inserted into the program instructions. The protective instructions are utilized to detect and respond to attacks during execution of the program instructions.

Non-Patent reference, “Dynamic Taint Analysis for Automatic Detection, Analysis” by James Newsome and Dawn Song of Carnegie Mellon University, proposes a dynamic taint analysis solution for automatic detection of overwrite attacks. The approach does not need source code or special compilation for the monitored program, and hence works on commodity software. To demonstrate this idea, they implemented TaintCheck, a mechanism that can perform dynamic taint analysis by performing binary rewriting at run time.

Non-Patent reference, “gFuzz: An instrumented web application fuzzing environment” by Ezequiel D. Gutesman of Core Security Technologies, Argentina, introduces a fuzzing solution for PHP web applications that improves the detection accuracy and enriches the information provided in vulnerability reports. They use dynamic character-grained taint analysis and grammar-based analysis in order to analyze the anatomy of each executed SQL query and determine which resulted in successful attacks. A vulnerability report is then accompanied by the offending lines of source code and the fuzz vector (with attacker-controlled characters individualized).

One shortcoming of prior art teachings is that they suffer from poor accuracy while also at times requiring source code for analysis as opposed to just bytecode/assembly code, or they attempt to simplify the bytecode/assembly code before analysis. Other prior art work teaches running both dynamic and static analysis components in an independent or serial fashion. Furthermore earlier approaches attempt to exhaustively map all data flows in a decompiled or intermediate representation of a software system which impairs performance and slows the overall process. Relatedly, prior art teachings do not provide for advantages afforded by concurrent multi-core or multi-CPU processing infrastructure that is commonplace these days, to allow for distributed analysis of very large target software systems with high precision. Similarly, prior art teachings suffer from poor performance by not proper utilizing the benefits of precomputation and caching of the analysis of basic blocks of code.

OBJECTS OF THE INVENTION

In view of the shortcomings of the prior art, it is an object of the present invention to provide for high-precision, high- performance software analysis system and methods that do not require the source code of the analyzed program.

It is another object of the invention to not require an exhaustive processing of all data flows in a program but rather than the ones that include unsafe data.

It is another object of the invention to not rely on decompliation of executable binary code.

It is yet another object of the invention to allow for distributed processing of the analysis framework taught by the invention by taking advantage of a multi-CPU or multi-core processing environment, consequently allowing for analysis of very large target software systems with efficiency and high precision.

Still other objects and advantages of the invention will become apparent upon reading the detailed description in conjunction with the drawing figures.

SUMMARY OF THE INVENTION

The objects and advantages of the invention are secured by a system and methods of detecting software vulnerabilities in a computer program by analyzing the compiled code of that computer program. The invention optionally uses the source code of the computer program in conjunction with the compiled code, but having the source code is not a requirement of the invention. The invention teaches utilizing an instruction model for each instruction of the compiled code. The instruction model for a given instruction includes the instruction location, debug information, instruction type, operands, existing memory state requirements, bytecode metadata, potential security attributes, basic block membership and function/method membership if applicable of that instruction.

The invention further uses a control flow graph for each instruction that complements the instruction model of that instruction, and includes all potential control flow paths, and a bidirectional list of predecessor instructions of that instruction. Preferably, the compiled code is instrumented at random and critical points in the code. There is a data flow model to record the flow of unsafe data during the execution of the program. The system has the means to analyze the data flow model and to create a security finding corresponding to each instruction that calls an unsafe function on unsafe data. These security findings are aggregated in a security report along with the corresponding debug information and the optional source code information for each instruction that triggered the security finding.

In the preferred embodiment of the invention, the instruction model also includes placeholders for additional attributes. These additional attributes may include information for pointer aliases or unsafe data flow. The pointer alias information may include an aliasing map containing pointers that have the same address values given a subset of or all possible control flows of the instructions of the compiled code.

In another embodiment, the instruction model also contains attributes that are deduced from other attributes of the instruction model. These derived attributes may include values for memory locations, processor registers and variable types associated with the given instruction of the instruction model. In another preferred embodiment, the flow of unsafe data is recorded in a data flow file that utilizes a common file format such as XML, based on which the data flow model is at least partially populated. In an advantageous embodiment of the invention, an analyzer module is used to analyze the instruction model, control flow graph and the data flow model to detect software vulnerabilities in the compiled code.

In a highly advantageous embodiment of the invention, a set of concurrent worker threads are spawned that take advantage of a multi-core or multi-node or multi-machine or multi-CPU processing platform, to analyze instructions where an unknown or unsafe external input (or taint) data is provided to the program and an unsafe function or method is called upon it. In another preferred embodiment of the system, the security findings in the security report also contain a full trace of the unsafe data at the instruction that triggered the security finding, along with the line numbers of the source file if available, a human-readable description of the finding, a risk rating and optionally one or more recommendations to address the security finding.

The methods of the invention further teach the steps required to carry out the operation of the system. The invention teaches the steps required to detect software vulnerabilities of a computer program by taking as input the compiled code of the program, and optionally its source code. It then creates an instruction model and a control flow graph for each instruction in the compiled code. If further creates a data flow model to record the flow of unsafe data during the execution of the compiled code. The compiled code is instrumented at random and critical control flow points of the program.

For a given instruction, the instruction model includes the instruction location, debug information, instruction type, operands, existing memory state requirements, bytecode metadata, potential security attributes, basic block membership, function/method membership if applicable and class membership of the given instruction. The instruction model also includes placeholders for additional attributes, including pointer aliasing information, unsafe data flow information and attributes that are deduced from other attributes including values of memory locations, values of processor registers and variable types for the given instruction.

For each instruction, the control flow graph is populated with all potential control flow paths, and a bidirectional list of predecessor instructions. Finally, for each instruction, the data flow model is populated by running the compiled code with the instrumentation at least once and recording the flow of unsafe data for each run. In another preferred embodiment, this recording of unsafe data flow is first done in a data flow file in a common file format such as XML, and the population of the data flow model is based on the data flow file.

The compiled code is scanned according to the methods provided by the invention to find each instruction where an external input is supplied to the program, denoting unknown, unsafe data. If that instruction calls an unsafe function on the unsafe data, this triggers the creation of a security finding. As the analysis is performed, all security findings are aggregated in a security report.

In the preferred embodiment, each security finding in the security report includes the debug information for the instruction that triggered the finding, along with the line numbers of the source code if available, a trace of the unsafe data from its origin to termination, identifier values of any processor registers or variables containing the unsafe data, a description of the security finding, a risk rating, and optionally one or more recommendations to address/remedy the security finding. Appropriate highlighting of these elements in the security report is also performed to make the report visually presentable, readable and easy to consume.

In another advantageous embodiment, three lists are created for each instruction. These lists are Unsafe1, Unsafe2 and Unsafe3. All instructions that are determined to be unsafe i.e. they use unsafe data by calling an unsafe function, are added to a list called Worklist. A set of concurrent worker threads are spawned, each thread selecting and processing an instruction at random from Worklist. Based on the control flow graph and data flow model earlier created, for each instruction in Worklist, Unsafe1 list is populated with incoming unsafe data at that instruction, Unsafe2 list with unsafe data currently being processed by that instruction, and Unsafe3 list with unsafe data that has been fully processed by that instruction.

As the worker threads process the instructions, the contents of the three lists for each instruction are updated based on the control flow graph of that instruction as data flows from its Unsafe1 list to Unsafe2 list to Unsafe3 list and into the Unsafe1 list of the downstream instruction. If new unsafe data is added to the Unsafe1 list of an instruction that calls an unsafe function, it is re-added to the Worklist and a security finding is generated, and the above process is repeated. Ultimately, the spawning of worker threads is concluded when there are no more unsafe instructions left in Worklist, or a predetermined timeout period has elapsed during the above processing. Concurrency locks are provided for each of the three lists, Unsafe1, Unsafe2 and Unsafe3 above, and at each step of the above processing, these locks are used to ensure the integrity of the contents of these lists. When a list is no longer being used, its concurrency lock is released (unlocked).

In a highly advantageous embodiment, worker threads are distributed across a multi-core or multi-processor or multi-CPU processing environment to improve the performance of the analysis and to allow processing of very large target software programs. In a similarly advantageous embodiment, the traversal of the control flow graph by the worker threads is performed according to custom unsafe data propagation rules provided by the user. In another advantageous embodiment the security findings are created by an analyzer module.

Several ways for enhancing the performance of the system have also been provided by the invention. In a highly preferred set of embodiments, a precomputation or preprocessing phase is performed first. In the precomputation phase, all basic blocks in the code are identified. A basic block is a straight-line code sequence with no branches.

For each control flow path of the basic block, the data locations referenced by the instructions are identified. The data locations can include a local variable, a register value, a stack value, or a pointer reference. These data locations are tracked as the basic block is traversed through to its end-point. Then a 1-to-many data flow map is created that includes each beginning data location encountered in the basic block, and its corresponding one or more ending data locations at the end of the basic block. These data flow inputs and outputs are recorded and cached in a data flow map.

Subsequently, during normal operation when data flow model is being populated, if any unsafe instruction is determined to be a member of a basic block, then the data flow map is simply consulted to see where the data locations referenced by the unsafe instruction may end up during the execution of the basic block. This way, the basic block does not need to be traversed instruction by instruction. Then any time, during the analysis of the subsequent code, if an instruction is determined to be a part of the basic block, an exhaustive iteration/execution of the basic block is avoided. These techniques result in significant performance improvements for the system.

Clearly, the system and methods of the invention find many advantageous embodiments. The details of the invention, including its preferred embodiments, are presented in the below detailed description with reference to the appended drawing figures.

BRIEF DESCRIPTION OF THE DRAWING FIGURES

FIG. 1 is a block diagram view of the software vulnerabilities detection system according to the current invention.

FIG. 2 is a conceptual diagram of the instruction model according to the current invention.

FIG. 3 is a diagram of the control flow graph of an instruction according to the invention.

FIG. 4 is a conceptual diagram of the data flow model of an instruction according to the invention.

FIG. 5 is a detailed block diagram view of the elements and their workings according to the current invention.

FIG. 6 is a flowchart comprising the analytical steps of the algorithm required for the detection of software vulnerabilities according to the current invention.

FIG. 7 is a diagram depicting a typical basic block or straight-line code sequence as utilized by an additional set of embodiments that employ precomputation and caching to improve performance.

FIG. 8 shows how the additional set of embodiments of FIG. 7 arrive at a data flow mapping.

FIG. 9 is a variation of FIG. 5 depicting the use of data flow mapping obtained in FIG. 8.

DETAILED DESCRIPTION

The figures and the following description relate to preferred embodiments of the present invention by way of illustration only. It should be noted that from the following discussion, alternative embodiments of the structures and methods disclosed herein will be readily recognized as viable alternatives that may be employed without departing from the principles of the claimed invention.

Reference will now be made in detail to several embodiments of the present invention(s), examples of which are illustrated in the accompanying figures. It is noted that wherever practicable, similar or like reference numbers may be used in the figures and may indicate similar or like functionality. The figures depict embodiments of the present invention for purposes of illustration only. One skilled in the art will readily recognize from the following description that alternative embodiments of the structures and methods illustrated herein may be employed without departing from the principles of the invention described herein.

The present invention will be best understood by first reviewing the software vulnerabilities detection system 100 according to the current invention as illustrated in FIG. 1. Vulnerabilities detection system 100 comprises computer program 102 in the form of its compiled code 104 and optionally source code 106 that resulted in its compiled code 104. Computer program 102 is the target program to be analyzed by system 100 for software vulnerabilities. Having source code 106 is desirable but not required by software vulnerabilities detection system 100 according to the invention. Vulnerabilities detected by system 100 in computer program 102 may allow exploitative attacks by potential adversaries or hackers. Such attacks include, but are not limited to denial of service attacks, code injection attacks and 2^(nd) order attacks such as cross-site scripting (XSS) attacks.

Software vulnerabilities detection system 100 comprises instruction model 110, control flow graph 112 and data flow model 114. Based on instruction model 110, control flow graph 112 and data flow model 114, software vulnerabilities detection system 100 performs analysis 116 to produce security report 118 comprising the security findings discovered during analysis 116.

Readers with average skill in the art will understand that compiled code 104 can be executable binary code, machine code, or object code that can run directly on a hardware platform such as x86, Sparc, Mac, HP, IBM Mainframe, etc. or it can be an intermediate bytecode or portable code that can run in a given runtime environment such as Java Virtual Machine (JVM). Source code 106 can be in any programing language such as C, C++, Java, Assembly, Cobol, SQL, etc. Furthermore, source code 106 can be in any 2^(nd), 3^(rd), 4^(th) or higher generation programming language without departing from the principles of the invention. A highly advantageous feature of the current invention is that source code 106 is desirable, but not required to achieve the objects of the invention. Not requiring the presence of source code 106 overcomes many practical limitations of the prior art.

Instruction model 110 is a programming construct used by the invention to model each instruction of compiled code 104. This programming construct comprises all the necessary and desirable attributes required by system 100 to model each instruction of compiled code 104. These attributes include the instruction location (e.g. base address and relative memory location of the instruction), debug information if available (e.g. variable name annotations and/or source code line annotations), type of the instruction (e.g. mov, add, sub), its operands (e.g. eax register, an integer immediate value, operand stack reference, local value reference) and its potential security attributes.

These attributes further include existing memory state requirements of the instruction (e.g. basic block derived invariant conditions), basic block membership (e.g. start and end references for all basic blocks encompassing an instruction), function/method membership (e.g. what functions/methods the instruction belongs to) and/or class membership (e.g. which object classes the instruction belongs to), if applicable. Those with average skill in the art will find these attributes familiar from the fundamentals of software engineering and computer programming. FIG. 2 provides a conceptual representation of instruction model 110 using a familiar notation for data structures and member associations in computer programming.

Referring to FIG. 1, during the execution of compiled code 104, user input 108 may be provided by the operator or user of computer program 102 whose vulnerabilities are to be detected. Those familiar with the art will understand that user input 108 represents a potential security risk for computer program 102 as it may intentionally or otherwise, violate the bounds of a program variable which may affect the integrity of computer program 102 or the data it is operating on. Thus user input 108 represents ‘taint’ or unsafe data, as will be understood by skilled people of the art. User input 108 can be provided in many different ways, for example, via a web form and keyboard, a file, an input/output buffer or stream, a pipe, screen redirect, etc.

Compiled code 104 according to the invention is preferably instrumented at random and critical control flow points of the program. Those familiar with the art will understand that instrumentation may refer to code instructions and metadata augmented to the computer program that allow monitoring of its behavior, performance and operation more closely than during normal execution, and may generate additional logging and debug output to the screen or files as desired. As provided by the invention, computer program 102 is preferably instrumented at random points within the program. Instead of or in addition to that, the program is also preferably instrumented at points where there is a critical control flow transition in the program.

Those familiar with the art will understand that there are many ways to determine these points where instrumentation may be provided in computer program 102. In a preferred embodiment, instructions in compiled code 104 can be randomly selected for instrumentation. Alternatively or in addition, a pre-processor can be used to determine the critical control flow points in program 102 prior to its execution, and then instrumentation can be added at those points in program 102. Indeed, it is allowed by the invention to instrument entire or none of computer program 102, without departing from the principles of the invention. The instrumentation of program 102 allows observing and modification of unsafe data as it flows through program 102 according to the invention.

The invention further uses control flow graph 112 for each instruction that complements instruction model 110 of that instruction. Control flow graph 110 for a given instruction of compiled code 104 is populated with all potential control flow paths of that instruction, assuming there is no overwriting of the underlying instructions. Control flow graph 112 for a given instruction also contains a bidirectional list of its predecessor instructions. FIG. 3 represents control flow graph 112 for an instruction I according to the teachings of the invention. In FIG. 3, each instruction is represented by a circle. Instruction I has 4 predecessor instructions P and 3 successor instructions S representing all possible control flow paths for I as shown in the figure. All P instructions will be contained in a bidirectional list in control flow graph 112 for instruction I as represented by the dashed lines in FIG. 3.

Referring back to FIG. 1, the invention further comprises data flow model 114. During the execution of program 102, the movement of unsafe data is recorded in data flow model 114. As a consequence of successive instructions, when unsafe data moves from one variable, processor register, stack value or pointer reference, to another such data location, this movement is recorded in data flow model 114 according to the teachings of the invention. FIG. 4 represents an example data flow model 114 populated according to the teachings of the invention.

In FIG. 4, variable V1 contains unsafe data that may have been previously supplied by user input 108 as taught earlier (see FIG. 1). Tainted data V1 is then moved to processor register AX in the next instruction of one control flow path, and then copied to variable V2. The subsequent instruction then calls an unsafe function on variable V2 representing a potential security risk in the computer program. FIG. 4 also illustrates additional control flow paths in data flow model 114 where the unsafe function call is performed on the tainted data contained in variable V2. Those familiar with the art will know the various types of unsafe function calls that may result in a potential security flaw in the code that can be exploited by an adversary. For example, in C/C++ “char*strcpy(char*dest, const char*src)” function on tainted data is an unsafe function call, because it can allow a security condition called buffer overflow to happen and damage the integrity of computer program 102 of FIG. 1, or its data, or worse allow a malicious adversary to inject harmful code or virus into the computer program.

According to the teachings of the current invention as explained above, data flow model 114 only records the flow of unsafe data during the execution of the program, as opposed to attempting to include and record all potential data flows. This significantly reduces the performance overhead and memory requirements of software vulnerabilities detection system 100, allowing it to analyze large target software systems more comprehensively than possible through the teachings of prior art. This also allows the current invention to not require decompilation of compiled code, as required by some prior art teachings.

According to the main embodiment of the invention, based on instruction model 110, control flow graph 112 and data flow model 114, all instructions in computer program 102 that call an unsafe function on unsafe data, trigger a security finding which is recorded in security report 118 as represented in FIG. 1. Each such security finding contains debug information of the instruction that triggered the security finding, along with its source code information, if available. Security report 118 exposes the vulnerabilities in computer program 102 that can be appropriately remediated to prevent exploitative attacks by amateur and professional adversaries according to the teachings of the invention.

As represented in FIG. 2, instruction model 110 further includes placeholders for additional attributes or deduced attributes that may not be immediately known at the time of the initial creation of instruction model 110. These additional attributes may include pointer aliases. Pointer aliases represent pointers that point to or contain same memory address for multiple control flow paths of computer program 102. In addition, instruction model 110 for a given instruction I may include information related to its predecessor instructions P as represented in FIG. 3, and any additional information or metadata as deemed necessary to facilitate recording of the flow of unsafe data as represented in FIG. 4. Furthermore, instruction model 110 may also include information deduced from other attributes. Examples of such derived attributes include memory locations or addresses, processor registers and variable type information for the given instruction based on its type, debug information and bytecode metadata.

According to an additional embodiment of the invention, analysis 116 in FIG. 1 may be performed by an analyzer module. Analyzer module may be a part of system 100 or may be external to it. If it is external to system 100, appropriate remote invocation calls or function calls or remote procedure calls (RPC) may be implemented to call the external module, as will be obvious to those skilled in the art. Indeed it is possible that the analyzer module is a 3^(rd) party software with its own application programming interface (API), without departing from the principles of the invention. Similarly, in a highly advantageous embodiment, analysis 116 is performed by worker threads that are spawned specifically for that purpose. These worker threads may then be distributed across a cluster of computing nodes, processors or cores, in a multi-CPU or multi-core, parallel processing environment.

Further embodiments allow security report 118 of FIG. 1 to include an execution trace of unsafe data corresponding to each security finding populated in the report. The execution trace may contain the origin and termination information for the unsafe data that ultimately caused the security finding to be triggered. For example, if unsafe data was provided as a user input in function or instruction I1 and it traversed through several intervening functions or instructions I2 . . . I9 before being discarded or reset in instruction I10, then execution trace for the corresponding security finding in security report 118 may contain the entire lifecycle or trace of that data along with the names of functions or instructions I1 . . . I10. In addition, security report 118 may contain a human friendly description of the security finding, and a risk rating or risk factor assigned to the security finding by system 100. Depending on the severity of the vulnerability associated with each finding, vulnerabilities detection system 100 may assign a risk rating from 1 to 10, or as a percentage, or use some other suitable rating system. Security report 118 may also contain one or more recommendations on how to address the security finding, or provide a ‘fix’ for the problem. Such recommendations and risk assignments may be based on a knowledgebase (not shown) derived from subject matter expertise in detecting and correcting such software vulnerabilities.

The methods of the invention describe the steps required to operate software vulnerabilities detection system 100 of FIG. 1. In the preferred embodiment, computer program 102 is executed at least once and the flow of unsafe data through the program is first recorded in a data flow file 140 as shown in

FIG. 4. Based on the contents of data flow file 140, data flow model 114 is populated. The format of data flow file 140 can be any suitable file format, such as XML, plain text, any other markup format, or a binary (or compiled) format, without departing from the principles of the invention.

In a preferred embodiment, three lists, Unsafe1, Unsafe2, Unsafe3 are created for each instruction. Persons with average skill in the art will understand that these lists can be linked lists, arrays or any other appropriate data structures of computer software without departing from the principles of the invention. Compiled code 104 is scanned to find each instruction where an external input is supplied to the program, denoting unknown, unsafe or ‘taint’ data. If that instruction calls an unsafe function on the unsafe data, that instruction is added to another list, Worklist. Persons skilled in the art will again understand that Worklist can be a linked list, an array or any other suitable data structure. List Worklist 160, Unsafe1 list 180, Unsafe2 list 184 and Unsafe3 list 186 are shown in FIG. 5 along with the other elements of the invention as taught earlier.

Next, a set of concurrent worker threads are spawned, each thread selecting and processing an instruction at random from Worklist 160 of FIG. 5. Based on instruction model 110, control flow graph 112 and data flow model 114, for each instruction in Worklist 160, Unsafe1 list 180 is populated with incoming unsafe data at that instruction, Unsafe2 list 182 with unsafe data currently being processed by that instruction, and Unsafe3 list 184 with unsafe data that has been fully processed by that instruction. As the worker threads process the instructions of compiled code 104, the contents of Unsafe1 list 180, Unsafe2 list 182, Unsafe3 list 184 for each instruction are updated based on control flow graph 112 of that instruction as data flows from its Unsafe1 list 180 to Unsafe2 list 182 to Unsafe3 list 184 and into Unsafe1 list 180 of the successor instruction.

If new unsafe data is added to Unsafe1 list 180 of an instruction that calls an unsafe function, a new security finding 200 is created and added to security report 118 as represented in FIG. 5, and that instruction is re-added to Worklist 160, and the above process is repeated. Ultimately, the spawning of worker threads is concluded when there are no more unsafe instructions left in Worklist 160, or a predetermined timeout period has elapsed during the above processing. FIG. 6 shows the above algorithm in a flowchart format where an unsafe instruction denotes an instruction that calls an unsafe function on unsafe data as explained above, and the label instr is used to abbreviate the term instruction.

Referring to FIG. 5, concurrency locks 190, 192, 194 are provided for each of Unsafe1 list 180, Unsafe2 list 182 and Unsafe3 list 184 respectively, and at each step of the above processing, these locks are used to ensure the integrity of the contents of these lists. When a list is no longer being used, its concurrency lock is released (unlocked). Those skilled in the art will understand how the contents of Unsafe1 list 180, Unsafe2 list 182 and Unsafe3 list 184 will be updated as explained above. Further explained, when a worker thread selects an instruction to process from Worklist 160, it locks its Unsafe2 list 182 and Unsafe3 list 184, and also temporarily locks its Unsafe1 list 180 while it imports data from its Unsafe1 list 180 to Unsafe2 list 182. The worker thread then statically analyzes the currently selected instruction to determine from its incoming unsafe data in Unsafe1 list, currently processed data in Unsafe2 list and fully processed data in Unsafe3 list, what other instructions that unsafe data may propagate to. This determination is based on the attributes of the current instruction as contained in its instruction model 110, and any other custom unsafe data propagation rules pre-defined or provided by the user.

Examples of custom unsafe data propagation rules include specifying that a function or method, e.g.

execSqlStatement(String query), should never receive unsafe or “taint” user input in its first and only parameter. Such a rule could be expressed as an XML file defining regular expressions to identify the specific class and method for this call, along with a numeric value identifying that the first parameter should never be tainted or uncontrolled, along with security information defining the security impact of such a condition. Another example would be a rule which identifies that the subString(Integer from) call will propagate the value of its object instance to its return value, which could be similarly expressed in an xml file, and identifying the return value. Still other examples of custom rules include source rules, which define the insertion of uncontrolled or tainted data into a program and cleanse rules which define methods that are known to control data such that the data can afterwards be considered safe in one or more ways.

Referring back to FIG. 5 and preceding teachings, based on control flow graph 112 of the current instruction, the current worker thread aggregates all possible control flow destinations of the current instruction in a list Next Instructions (not shown). Subsequently, for each instruction in Next_Instructions list, the current worker thread locks its Unsafe1 list and adds outgoing processed unsafe data contained in its Unsafe3 list 184, to the incoming unsafe data contained in Unsafe1 list 180 of the instruction selected from Next_Instructions list. As explained above, if unsafe data is added to Unsafe1 list of an instruction that calls an unsafe function, a security finding 200 is added to security report 118 and that instruction is re-added to Worklist 160. The above process continues until there are no more instructions left to process in Worklist 160 or a timeout period has elapsed.

In a highly advantageous embodiment, worker threads are distributed across a multi-core or multi-CPU or multi-machine or multi-node processing environment to improve the performance of the analysis and to allow processing of very large target software programs. In a similarly advantageous embodiment, the traversal of the control flow graph by the worker threads is performed according to custom unsafe data propagation rules provided by the user. In another advantageous embodiment the security findings are created by an analyzer module. Conveniently, the security findings as discovered, may be added to a list e.g. FindingsList, which may be post-processed to generate security report 118.

In another advantageous embodiment, security report 118 as shown in FIG. 5 contains a full execution trace of unsafe data corresponding to each security finding 200 populated in security report 118. The execution trace may contain the origin and termination information for the unsafe data that ultimately caused security finding 200 to be triggered. As an example, consider that unsafe data was provided as a user input in function or instruction I1 and it traversed through several intervening functions or instructions I2 . . . I9 before being discarded or reset in instruction I10. Then execution trace for corresponding security finding 200 in security report 118 may contain the entire lifecycle or trace of that data along with the names/labels of instructions I1 . . . I10 and filename(s) and corresponding line numbers in the source files from source code 106 if available, or obtained from debug information or assembly instructions.

If source code 106 is available, each source file corresponding to the above trace is parsed into an abstract syntax tree or trees, and the line numbers and offsets for non-keyword identifier tokens is generated. Persons skilled in the art will understand that these non-keyword identifier tokens will represent user or custom variables, as opposed to keywords belonging to the grammar of the programming language itself. Using the abstract syntax tree or trees above, corresponding to each instruction in the trace, the identifier names and values of any variables or processor registers that contained the unsafe data is obtained using the debug information, and then added to the trace information.

In addition, security report 118 of FIG. 5 may be properly formatted to be visually appealing with proper highlighting of important pieces of information for each security finding 200, and contain a human friendly description of the finding along with a risk rating or risk factor assigned to the finding by system 100. Depending on the severity of the vulnerability associated with each security finding 200, vulnerabilities detection system 100 may assign a risk rating from 1 to 10, or as a percentage, or use some other suitable rating system.

Security report 118 may also contain one or more recommendations on how to address security finding 200, or ‘fix’ the problem. Such recommendations and risk assignments may be based on a knowledgebase (not shown) derived from subject matter expertise in detecting and correcting such software vulnerabilities. The knowledgebase may be further designed to continuously augment its content either automatically or with human assistance or by a combination of both automatic and manual means, as vulnerabilities detection system 100 operates over time.

In a related set of embodiments, software vulnerabilities detection system and the associated methods employ several techniques to improve the performance of the system. These embodiments of the instant invention precompute and cache the results of the analysis of a basic block or a set of basic blocks. Those skilled in the art will understand that a basic block in computer software is a straight-line code sequence with no branches in except at the entry and no branches out except at the exit of the basic block. Such a straight-line piece of code makes it highly attractive for software analysis since only one path sequence of code needs to be considered. Compilers routinely break down complex code into its constituent set of basic blocks to perform their code analysis.

For each basic block, the present invention precomputes and saves/caches the flow of data at the beginning of the basic block, also referred to as data flow input, and at the end of the basic block, also referred to as data flow output. Then during the normal operation of performing analysis of the whole code, this cached data flow is reused for each instruction that is a member of the precomputed basic block. This results in significant performance improvements during the operation of the system. We will now look at the workings of these advantageous embodiments in detail.

Let us consider FIG. 7 illustrating a basic block or a straight-line piece of code 300. Basic block 300 of FIG. 7 starts at instruction I1 and ends at instruction I6, while progressing through intervening sequential instructions I2, I3, I4 and I5. FIG. 7 further shows the actual exemplary software commands corresponding to instructions I1 . . . I6. Specifically, instruction I1 is a move instruction, instruction I2 is a copy instruction, and so on. The operands for these instructions will be introduced in reference to the rest of this explanation shortly.

The reader will note that the specific instructions in basic block 300 of FIG. 7 are reminiscent of assembly/assembler code however that is not a requirement imposed by the present invention, whose teachings apply equally to machine code, as well as higher level programming languages such a 3^(rd) generation (3GL) or 4^(th) generation programming languages (4GL).

As a part of the precomputation and caching phase for significantly improving the performance of the system according to the present embodiments, basic blocks such as 300 shown in

FIG. 7 are identified upfront. From our earlier teachings we see that instructions I1 through I5 each have only one control flow path because they all have a single successor instruction. This is a direct result of the definition of a basic block. Of course, instruction I6 however, may have one or more control flow paths because it is the ending instruction of basic block 300.

After the identification of basic blocks as a part of the precomputation phase, control flow paths for each instruction in the basic block are statically iterated over. In other words, each instruction of the basic block is traversed without actually executing the code. Conveniently, the present invention stores the instructions of the basic blocks identified, in an array or arrays of instructions. This facilitates the iteration process during the precomputation phase being taught.

The purpose of the above iteration of basic block instructions is to identify all data storage locations or simply data locations that are referenced by any instruction of the basic block. These data locations may include a processor register, a local variable, a data location referenced by a pointer or an address (also referred to as a pointer reference), and/or an entry or data value on the stack (also referred to as stack value). As the basic block is iterated over, the data flow for each such location is tracked until the end of the basic block. All these data flows are then saved in a 1-to-many mapping since a beginning data location can have one or more ending data locations. Note that for convenience we will still call this mapping a 1-to-many map/mapping even though it is not necessary for there to be more than one ending data location for each beginning data location, in which case this mapping may actually contain 1-to-1 entries.

Thus for each data location as identified above, its data value is tracked as the instructions of the basic block are traversed. At the end of the basic block, the ending data location for each beginning data location is saved. Each such beginning data location represents a data flow input into the basic block, and at each ending data location corresponding to a beginning data location represents a data flow output out of the basic block. This 1-to-many correspondence of each beginning data location of a data value and its ending data location(s) are saved in a precomputed map or mapping.

FIG. 8 illustrates the above described process as an exemplary precomputation phase 302 of the instant invention. In FIG. 8, basic block 300 of FIG. 7 is represented by the dashed lines and instruction nodes I1 . . . I6. Basic block 300 is used to precompute the 1-to-many data flow mapping described above. In other words, in FIG. 8, data values referenced by basic block 300 at various data locations Li are tracked as basic block 300 is traversed. Specifically, move instruction I1 moves the data value stored in variable V1 at data location L1 to processor register AX identified as data location L2. Copy instruction I2 copies the contents of register AX identified by data location L2 to variable V2 identified as data location L3. From here onwards, we will denote a data value V at a data location L by its short form L:V. For instance, Copy instruction I2 above copies L2:AX to variable L3:V2.

Similarly, add instruction I3 adds L4:S1 to L3:V2 (and stores the result in L3:V2), where S1 represents a data value stored on the stack. Then add instruction I4 adds L5:CX to L1:V1 (and stores the results in L1:V1), where CX is a processor register. Move instruction I5 moves L5:CX to L6:DX where DX is a register. Finally, subtract instruction I6 subtracts the contents of variable V1 identified by data location L1 from the data value stored at pointer reference P1 and stores the results at pointer reference P1 identified by location L7.

Now let us analyze what has been accomplished above. As basic block 300 is iterated over instruction by instruction, each data value identified by data location Li is tracked until the point where basic block 300 ends at instruction I6. Specifically, beginning data location L1 has three ending data locations, L3 (representing variable V2), L6 (representing register DX) and L7 (representing the data location identified by pointer reference P1). These ending data locations are illustrated by oval (terminator) shapes in the diagram of FIG. 8.

Beginning data location L2 (representing register AX) has one ending data location L3 (representing variable V2). Similarly, beginning data location L4 has one ending data location L3, and beginning data location L5 has one ending data location L6. Note that the mapping obtained above is a 1-to-many mapping for location L1, and 1-to-1 mappings for locations L2 . . . L5. However we will still call such a data flow mapping as a 1-to-many data flow map/mapping as already noted above. The 1-to-many data flow map for basic block 300 obtained above, is presented in Table 1 below. Note that any beginning data location Lj will also trivially be its own ending data location Lj. These reflexive entries are eliminated from Table 1 for clarity.

TABLE 1 Beginning Location Ending Location L1 L3 L1 L6 L1 L7 L2 L3 L4 L3 L5 L6

Once the data flow map as exemplified in Table 1, is obtained for each basic block as a part of preprocessing or precomputation phase 302 of FIG. 8, the present embodiments of the instant invention are ready to perform their normal operation as provided by earlier teachings. The major difference afforded by the present embodiments occurs during the population of data flow model 114 (see FIG. 1 and FIG. 4 and the associated explanation) when the target program is being executed. Specifically, if an unsafe instruction is determined to be a part of a basic block for which a data flow map has been precomputed, then instead of dynamically executing each instruction of that basic block, the data flow model is populated by fetching the corresponding beginning and ending data location entries from the precomputed and cached 1-to-many data flow map explained above.

Explained further, let us reconsider above example of FIG. 8 and assume that instruction I1 is an unsafe instruction. During the process of populating the data flow model of the compiled code, the present invention would determine instruction I1 to be a member/part of basic block 300. Instruction I1 could be unsafe because variable V1 referenced by I1 is a tainted variable, because it was inputted by a user via a web form. Recall from earlier teachings that such an input may be a tainted input because of the vulnerabilities that can be introduced as a result of such a web form/query.

Now in the present embodiments, instead of determining all the data flows, instruction by instruction, for variable V1 identified by location L1, the system would simply lookup Table and determine that the possible ending locations for L1:V1 are L3:V2, L6:DX and L7:*P1. This information can be directly fetched into the data flow model of the code being analyzed, without having to traverse the entire block 300 and tracking all data locations L1 . . . L7. This is true each time unsafe instruction I1 is called from anywhere in the code. Similarly, for each instruction I2 . . . I6 the same applies, i.e. if any of those instructions are deemed unsafe, Table 1 can instantaneously provide ending locations where tainted data may end up.

The above techniques of precomputing and caching provide significant performance improvements in the instant invention, since any compiled code can by decomposed into its constituent basic blocks. Once the precomputation and caching phase has been performed, any unsafe instruction deemed to be a member of those basic blocks can immediately benefit from the corresponding 1-to-many data flow map(s) to determine where its tainted data ends up. This avoids an exhaustive iteration of the block instruction by instruction. Any time during the subsequent operation of the system, if an unsafe instruction is encountered that is a member of a basic block whose data flow map has been precomputed, an instruction by instruction tracking of the referenced data values of that instruction till the end of the basic block can be avoided.

The remainder teachings of the earlier embodiments, including Worklist, Unsafe1, Unsafe2 and Unsafe3 lists, the use concurrency locks in the management of these lists, security findings and security report, recommendations and knowledgebase, as well as spawning concurrent threads to process members of Worklist, etc. still apply in the present embodiments. The difference of course is the precomputation and caching phase that speeds the performance of the subsequent operation of the system as explained above. Thusly, FIG. 9 is a variation of FIG. 5 showing a block diagram view of the elements and their workings according to the present embodiments, with the inclusion of the precomputed/cached data flow map 103 taught above.

In view of the above teaching, a person skilled in the art will recognize that the apparatus and method of invention can be embodied in many different ways in addition to those described without departing from the principles of the invention. Therefore, the scope of the invention should be judged in view of the appended claims and their legal equivalents. 

I claim:
 1. A software vulnerabilities detection system comprising: a) compiled code and optionally source code that resulted in said compiled code; b) an instruction model for each instruction of said compiled code comprising instruction location, debug information, instruction type and operands of each said instruction; c) a control flow graph for each said instruction comprising all potential control flow paths for each said instruction; d) a data flow model comprising recorded flow of unsafe data as observed during the execution of said compiled code, said data flow model utilizing a precomputation of data flow inputs and outputs associated with a basic block of said compiled code and optionally said source code; e) computing means for analyzing said instruction model, said control flow graph and said data flow model to obtain a security finding for each said instruction that calls an unsafe function on said unsafe data; and f) a security report comprising each said security finding, said security report comprising said debug information and said source code information if available.
 2. The software vulnerabilities detection system of claim 1, wherein said basic block is saved in an array of instructions.
 3. The software vulnerabilities detection system of claim 1, wherein said precomputation results in an identification of at least one data location referenced by an instruction of said basic block, said at least one data location selected from the group consisting of a register, a local variable, a pointer reference and a stack entry.
 4. The software vulnerabilities detection system of claim 3, wherein said identification is based on an iteration of each said control flow path that affects data contained in said at least one data location.
 5. The software vulnerabilities detection system of claim 4, further tracking the flow of said data through said basic block.
 6. The software vulnerabilities detection system of claim 4, further creating a mapping comprising one of said data flow inputs at a beginning data location, and one or more of said data flow outputs at one or more ending data locations, said one or more ending data locations and said beginning data location selected from said at least one data location.
 7. The software vulnerabilities detection system of claim 6, wherein said recorded flow of unsafe data utilizes said mapping for each instruction having a membership in said basic block.
 8. The software vulnerabilities detection system of claim 1 wherein said compiled code is instrumented.
 9. The software vulnerabilities detection system of claim 8 wherein said instrumentation is done at random and critical control flow points of said compiled code.
 10. The software vulnerabilities detection system of claim 1 wherein said instruction model further comprises placeholders for additional attributes, including pointer aliasing information and unsafe data flow information.
 11. The software vulnerabilities detection system of claim further comprising a set of concurrent worker threads, each processing an instruction from said compiled code where an external input is supplied.
 12. The software vulnerabilities detection system of claim 11 wherein said concurrent worker threads are executed across one or more items from the group consisting of CPU, processor, core, computing machine and node.
 13. A method of detecting software vulnerabilities comprising the steps of: a) accessing compiled code and optionally source code that resulted in said compiled code; b) creating an instruction model for each instruction of said compiled code, said instruction model comprising instruction location, debug information, instruction type and operands of each said instruction; c) creating a control flow graph associated with each said instruction model, said control flow graph comprising all potential control flow paths for each said instruction; d) creating and populating a data flow model by first precomputing data flow inputs and outputs associated with a basic block of said compiled code and optionally said source code; e) obtaining a security finding for each said instruction that calls an unsafe function on unsafe data; and f) generating a security report comprising each said security finding.
 14. The method of claim 13, saving said basic block in an array of instructions.
 15. The method of claim 13, wherein said step of precomputing results in identifying one or more data locations referenced by each instruction of said basic block.
 16. The method of claim 15, wherein said step of identifying is based on an iteration of each said control flow path that affects data contained in said one or more data locations.
 17. The method of claim 16, further tracking the flow of said data through said basic block.
 18. The method of claim 16, further creating a mapping comprising a beginning data location of a data flow input from amongst said data flow inputs, and one or more ending data locations of corresponding one or more from amongst said data flow outputs, said beginning data location and said ending data locations selected from said one or more data locations.
 19. The method of claim 18, wherein said step of obtaining said security finding first utilizes said mapping for each instruction having a membership in said basic block.
 20. The method of claim 13 further comprising the steps of: a) creating three lists unsafe1, unsafe2, unsafe3 for each said instruction; b) scanning said compiled code to determine instruction locations where external input is supplied and marking said instruction locations as containing unsafe data, and further creating a worklist of all instructions at said instruction locations that call an unsafe function; c) creating a set of concurrent worker threads, each thread selecting an instruction at random from said worklist, and processing it according to said control flow graph, and said data flow model, and populating said unsafe1 list with incoming unsafe data at said instruction, unsafe2 list with unsafe data currently being processed by said instruction, and unsafe3 list with unsafe data that has been fully processed by said instruction; d) adding an instruction to said worklist in step (c) above if said instruction has new data added to its said unsafe1 list and said instruction further calls an unsafe function, and repeating step (c); and e) concluding said creation of said worker threads if all instructions in said worklist have been processed as specified in steps (c) and (d), or if a predetermined time has elapsed. 